In this project, I will be creating a simple diabetes prediction model based on variables present in the dataset found on kaggle https://www.kaggle.com/andrewmvd/early-diabetes-classification¶
My Analysis¶
Here is the approach I took for this project:
Data Processing
Exploratory Data Analysis
Methods
Results & Discussion
1. Data Processing¶
In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
In [2]:
df_diabetes = pd.read_csv("diabetes_data.csv", sep = ";")
In [3]:
df_diabetes.head()
Out[3]:
In [4]:
print(df_diabetes.shape)
print(df_diabetes["class"].unique())
There are 520 rows and 16 predictor columns for the diabetes class. The diabetes class takes value 1 and 0. Next, I will convert the categorical gender variable to a binary variable¶
In [5]:
df_diabetes["gender"] = df_diabetes["gender"].apply({"Male":1, "Female":0}.get)
df_diabetes.head()
Out[5]:
Next, we will split the dataset into training and test datasets and utilize various algorithms to predict the response variable class¶
In [6]:
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
In [7]:
X = df_diabetes[df_diabetes.columns[:-1]]
Y = df_diabetes[df_diabetes.columns[-1]]
In [8]:
scaler = StandardScaler()
scaled_X = scaler.fit_transform(X)
In [9]:
X_train, X_test, Y_train, Y_test = train_test_split(scaled_X,
Y,
test_size=0.4,
random_state=101)
2. EDA¶
Next, I will conduct some basic exploratory data analysis to find out the gender and age profile of our dataset as well as our response variable "class"¶
In [10]:
sns.countplot(x="gender", data=df_diabetes)
Out[10]:
In [11]:
sns.countplot(x="class", hue="gender", data=df_diabetes)
Out[11]:
In [12]:
sns.histplot(df_diabetes["age"], kde=False, bins=10)
Out[12]:
From initial analysis, we have a majority male dataset but have more females diagnosed with diabetes. Additionally, the histogram shows that we have a majority age group of 50-60 years old¶
3. Methods¶
Model 1: Logistic Regression¶
In [13]:
from sklearn.linear_model import LogisticRegression
In [14]:
logmodel = LogisticRegression()
logmodel.fit(X_train, Y_train)
Out[14]:
Evaluate Model 1¶
In [15]:
predictions_log = logmodel.predict(X_test)
In [16]:
from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix, f1_score
In [17]:
print(classification_report(Y_test, predictions_log))
In [18]:
print(confusion_matrix(Y_test, predictions_log))
In [19]:
f1_log = f1_score(Y_test, predictions_log)
print(f1_log)
In [20]:
logmodel.coef_
Out[20]:
Model 2: K Nearest Neighbors¶
In [21]:
from sklearn.neighbors import KNeighborsClassifier
In [22]:
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, Y_train)
Out[22]:
Evaluate Model 2¶
In [23]:
predictions_knn1 = knn.predict(X_test)
In [24]:
print(classification_report(Y_test, predictions_knn1))
In [25]:
print(confusion_matrix(Y_test, predictions_knn1))
In [26]:
f1_knn1 = f1_score(Y_test, predictions_knn1)
print(f1_knn1)
Model 3: K Nearest Neighbors with tuning¶
In [27]:
error_rate = []
for i in range(1,40):
knn = KNeighborsClassifier(n_neighbors=i)
knn.fit(X_train, Y_train)
pred_i = knn.predict(X_test)
error_rate.append(np.mean(pred_i != Y_test))
In [28]:
plt.figure(figsize=(10,6))
plt.plot(range(1,40),error_rate,color='blue', linestyle='dashed', marker='o',
markerfacecolor='red', markersize=10)
plt.title('Error Rate vs. K Value')
plt.xlabel('K')
plt.ylabel('Error Rate')
Out[28]:
In [29]:
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, Y_train)
Out[29]:
Evaluate Model 3¶
In [30]:
predictions_knn2 = knn.predict(X_test)
In [31]:
print(classification_report(Y_test, predictions_knn2))
In [32]:
print(confusion_matrix(Y_test, predictions_knn2))
In [33]:
f1_knn2 = f1_score(Y_test, predictions_knn2)
print(f1_knn2)
Model 4: Decision Trees¶
In [34]:
from sklearn.tree import DecisionTreeClassifier
In [35]:
dtree = DecisionTreeClassifier()
dtree.fit(X_train, Y_train)
Out[35]:
Evaluate Model 4¶
In [36]:
predictions_dt = dtree.predict(X_test)
In [37]:
print(classification_report(Y_test, predictions_dt))
In [38]:
print(confusion_matrix(Y_test, predictions_dt))
In [39]:
f1_dt = f1_score(Y_test, predictions_dt)
print(f1_dt)
Model 5: Random Forests¶
In [40]:
from sklearn.ensemble import RandomForestClassifier
In [41]:
rfc = RandomForestClassifier(n_estimators=100)
rfc.fit(X_train, Y_train)
Out[41]:
Evaluate Model 5¶
In [42]:
predictions_rfc = rfc.predict(X_test)
In [43]:
print(classification_report(Y_test, predictions_rfc))
In [44]:
print(confusion_matrix(Y_test, predictions_rfc))
In [45]:
f1_rfc = f1_score(Y_test, predictions_rfc)
print(f1_rfc)
In [46]:
data = {"Method":["Logistic Regression", "KNN1", "KNN2", "Decision Trees", "Random Forest"],
"f1-score":[f1_log, f1_knn1, f1_knn2, f1_dt, f1_rfc]}
results = pd.DataFrame(data)
print(results)
4. Results & Discussion¶
I chose to utilize f1-scores to determine the most accurate model in predicting diabetes in a particular patient. f1-scores take into account both precision and recall to determine the percentage of positive predictions that were determined to be correct. In an issue such as diabetes, the false negative is highly critical.¶
Based on the respective f1 scores, it appears that the Random Forest Algorithm is the most suitable in predicting diabetes. Lets visualize the important variables¶
In [47]:
plt.figure(figsize=(12,6))
feature_imp = pd.Series(rfc.feature_importances_, index = X.columns).sort_values(ascending = False)
feature_plot = sns.barplot(x = feature_imp, y = feature_imp.index)
feature_plot.set_title("Feature Importance Plot")
feature_plot.set_xlabel("Score")
feature_plot.set_ylabel("Feature")
Out[47]:
